From: kaf24@firebug.cl.cam.ac.uk Date: Tue, 25 Apr 2006 17:13:39 +0000 (+0100) Subject: Some of the Linux PCI functions called by the virtual configuration X-Git-Tag: archive/raspbian/4.8.0-1+rpi1~1^2~16117^2~3 X-Git-Url: https://dgit.raspbian.org/%22http://www.example.com/cgi/success//%22http:/www.example.com/cgi/success/?a=commitdiff_plain;h=93bb8669b309756918df73dddf89442e27334eb8;p=xen.git Some of the Linux PCI functions called by the virtual configuration space handlers were making calls into ACPI code which uses semaphores. Since semaphores can not be locked while atomic (because they could sleep), I changed the way the PCI backend responds to requests from the frontend. Previously, the virtual configuration space handlers ran in the same context as the event channel interrupt handler (which was often atomic if not always atomic). Now the interrupt handler schedules a callback function (a bottom half) in the system work queue (keventd) that will get called in process context at a slightly later time. This allows the handlers in the virtual configuration space to run in process context and to call any core PCI function regardless of whether it will sleep or not. Signed-off-by: Ryan Wilson --- diff --git a/linux-2.6-xen-sparse/drivers/xen/pciback/pciback.h b/linux-2.6-xen-sparse/drivers/xen/pciback/pciback.h index 77d63e0030..09deb26522 100644 --- a/linux-2.6-xen-sparse/drivers/xen/pciback/pciback.h +++ b/linux-2.6-xen-sparse/drivers/xen/pciback/pciback.h @@ -11,6 +11,8 @@ #include #include #include +#include +#include #include struct pci_dev_entry { @@ -18,6 +20,9 @@ struct pci_dev_entry { struct pci_dev *dev; }; +#define _PDEVF_op_active (0) +#define PDEVF_op_active (1<<(_PDEVF_op_active)) + struct pciback_device { void *pci_dev_data; spinlock_t dev_lock; @@ -31,6 +36,10 @@ struct pciback_device { struct vm_struct *sh_area; struct xen_pci_sharedinfo *sh_info; + + unsigned long flags; + + struct work_struct op_work; }; struct pciback_dev_data { @@ -71,6 +80,7 @@ void pciback_release_devices(struct pciback_device *pdev); /* Handles events from front-end */ irqreturn_t pciback_handle_event(int irq, void *dev_id, struct pt_regs *regs); +void pciback_do_op(void *data); int pciback_xenbus_register(void); void pciback_xenbus_unregister(void); diff --git a/linux-2.6-xen-sparse/drivers/xen/pciback/pciback_ops.c b/linux-2.6-xen-sparse/drivers/xen/pciback/pciback_ops.c index 48305f549d..4dc35d581c 100644 --- a/linux-2.6-xen-sparse/drivers/xen/pciback/pciback_ops.c +++ b/linux-2.6-xen-sparse/drivers/xen/pciback/pciback_ops.c @@ -40,18 +40,25 @@ void pciback_reset_device(struct pci_dev *dev) pciback_config_reset(dev); } -irqreturn_t pciback_handle_event(int irq, void *dev_id, struct pt_regs *regs) +static inline void test_and_schedule_op(struct pciback_device *pdev) { - struct pciback_device *pdev = dev_id; + /* Check that frontend is requesting an operation and that we are not + * already processing a request */ + if (test_bit(_XEN_PCIF_active, (unsigned long *)&pdev->sh_info->flags) + && !test_and_set_bit(_PDEVF_op_active, &pdev->flags)) + schedule_work(&pdev->op_work); +} + +/* Performing the configuration space reads/writes must not be done in atomic + * context because some of the pci_* functions can sleep (mostly due to ACPI + * use of semaphores). This function is intended to be called from a work + * queue in process context taking a struct pciback_device as a parameter */ +void pciback_do_op(void *data) +{ + struct pciback_device *pdev = data; struct pci_dev *dev; struct xen_pci_op *op = &pdev->sh_info->op; - if (unlikely(!test_bit(_XEN_PCIF_active, - (unsigned long *)&pdev->sh_info->flags))) { - pr_debug("pciback: interrupt, but no active operation\n"); - goto out; - } - dev = pciback_get_pci_dev(pdev, op->domain, op->bus, op->devfn); if (dev == NULL) @@ -65,10 +72,25 @@ irqreturn_t pciback_handle_event(int irq, void *dev_id, struct pt_regs *regs) else op->err = XEN_PCI_ERR_not_implemented; + /* Tell the driver domain that we're done. */ wmb(); clear_bit(_XEN_PCIF_active, (unsigned long *)&pdev->sh_info->flags); notify_remote_via_irq(pdev->evtchn_irq); - out: + /* Mark that we're done */ + wmb(); + clear_bit(_PDEVF_op_active, &pdev->flags); + + /* Check to see if the driver domain tried to start another request + * in between clearing _XEN_PCIF_active and clearing _PDEVF_op_active */ + test_and_schedule_op(pdev); +} + +irqreturn_t pciback_handle_event(int irq, void *dev_id, struct pt_regs *regs) +{ + struct pciback_device *pdev = dev_id; + + test_and_schedule_op(pdev); + return IRQ_HANDLED; } diff --git a/linux-2.6-xen-sparse/drivers/xen/pciback/xenbus.c b/linux-2.6-xen-sparse/drivers/xen/pciback/xenbus.c index f073b35679..28074c34e8 100644 --- a/linux-2.6-xen-sparse/drivers/xen/pciback/xenbus.c +++ b/linux-2.6-xen-sparse/drivers/xen/pciback/xenbus.c @@ -31,6 +31,8 @@ static struct pciback_device *alloc_pdev(struct xenbus_device *xdev) pdev->evtchn_irq = INVALID_EVTCHN_IRQ; pdev->be_watching = 0; + INIT_WORK(&pdev->op_work, pciback_do_op, pdev); + if (pciback_init_devices(pdev)) { kfree(pdev); pdev = NULL; @@ -48,6 +50,11 @@ static void free_pdev(struct pciback_device *pdev) if (pdev->evtchn_irq != INVALID_EVTCHN_IRQ) unbind_from_irqhandler(pdev->evtchn_irq, pdev); + /* If the driver domain started an op, make sure we complete it or + * delete it before releasing the shared memory */ + cancel_delayed_work(&pdev->op_work); + flush_scheduled_work(); + if (pdev->sh_info) xenbus_unmap_ring_vfree(pdev->xdev, pdev->sh_area);